#include "UART.h"
#include "logic.h"
#include "main.h"
#include "usart.h"
#include "string.h"


void USARTInit(usart *_instance)
{
    // HAL_UART_Receive_DMA(_instance->usart_handle, _instance->recv_buff, _instance->recv_buff_size);
    // __HAL_UART_ENABLE_IT(_instance->usart_handle,UART_IT_IDLE);    
    // __HAL_DMA_DISABLE_IT(_instance->usart_handle->hdmarx, DMA_IT_HT);
    // HAL_UART_Receive_IT(_instance->usart_handle,_instance->recv_buff, 1);	//打开串口接收中断
    HAL_UART_Receive_DMA(_instance->usart_handle,_instance->recv_buff,_instance->recv_buff_size);
	__HAL_UART_ENABLE_IT(_instance->usart_handle,UART_IT_IDLE);
	
}



void USARTSend(usart *_instance, uint8_t *send_buf, uint16_t send_size, USART_TRANSFER_MODE mode)
{
    switch (mode)
    {
    case USART_TRANSFER_BLOCKING:
        HAL_UART_Transmit(_instance->usart_handle, send_buf, send_size, 100);
        break;
    case USART_TRANSFER_IT:
        HAL_UART_Transmit_IT(_instance->usart_handle, send_buf, send_size);
        break;
    case USART_TRANSFER_DMA:
        HAL_UART_Transmit_DMA(_instance->usart_handle, send_buf, send_size);
        break;
    default:
        while (1)
            ; // illegal mode! check your code context! 检查定义instance的代码上下文,可能出现指针越界
        break;
    }
}





// UART_REC userUart;
// UART_MEMCPY_BUFF usr_dma_Data;


// void USR_UART_Init()//串口初始化函数
// {
// 	__HAL_UART_ENABLE_IT(&huart2,UART_IT_IDLE);//启动IDLE中断
// 	__HAL_UART_ENABLE_IT(&huart3,UART_IT_IDLE);//启动IDLE中断
// 	__HAL_UART_ENABLE_IT(&huart1,UART_IT_IDLE);//启动IDLE中断

// 	userUart.userUart1.uartRecCount = 0;

// //	  注意串口DMA 发送时候应该如下顺序初始化DMA 和串口
// //	  MX_DMA_Init();
// //	  MX_USART1_UART_Init();
// //	  MX_UART4_Init();
// //	  MX_UART5_Init();
// //	  MX_USART2_UART_Init();
// //	  MX_USART3_UART_Init();
// //	  MX_USART6_UART_Init();

// 	HAL_UART_Receive_DMA(&huart1, (uint8_t *)&userUart.userUart1.ReciveBuff, sizeof(userUart.userUart1.ReciveBuff));
// 	HAL_UART_Receive_DMA(&huart2, (uint8_t *)&userUart.userUart2.ReciveBuff, sizeof(userUart.userUart2.ReciveBuff));
// 	HAL_UART_Receive_DMA(&huart3, (uint8_t *)&userUart.userUart3.ReciveBuff, sizeof(userUart.userUart3.ReciveBuff));
// }



// void UART1_IRQ_DataGet()//在串口1的中断服务函数中添加此函数用于缓存数据
// {
// 	if(USART1 == huart1.Instance)
// 	{
// 		if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE))
// 		{
// 			HAL_UART_DMAStop(&huart1);
// 			userUart.userUart1.uartRecCount = MAX_REC_COUNT - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);//用于统计DMA接收到了多少数据
// 			userUart.userUart1.RecFlag = true;
// //			printf("userUart.userUart1.uartRecCount is %d",userUart.userUart1.uartRecCount);
// //			memcpy(&usr_dma_Data.usr_uart1.DMAbuff,&userUart.userUart1.ReciveBuff,userUart.userUart1.uartRecCount);
// //			memset((uint8_t *)&userUart.userUart1.ReciveBuff,0,sizeof(userUart.userUart1.ReciveBuff));
// //			userUart.userUart1.uartRecCount = 0;
// 			HAL_UART_Receive_DMA(&huart1, (uint8_t *)&userUart.userUart1.ReciveBuff, sizeof(userUart.userUart1.ReciveBuff));
// 			__HAL_UART_CLEAR_IDLEFLAG(&huart1);
// 		}
// 	}
// }

// void UART2_IRQ_DataGet()//在串口1的中断服务函数中添加此函数用于缓存数据
// {
// 	if(USART2 == huart2.Instance)
// 	{
// 		if(__HAL_UART_GET_FLAG(&huart2,UART_FLAG_IDLE))
// 		{
// 			HAL_UART_DMAStop(&huart2);
// 			userUart.userUart2.uartRecCount = MAX_REC_COUNT - __HAL_DMA_GET_COUNTER(&hdma_usart2_rx);//用于统计DMA接收到了多少数据
// 			userUart.userUart2.RecFlag = true;
// //			printf("userUart.userUart2.uartRecCount is %d",userUart.userUart2.uartRecCount);
// //			memcpy(&usr_dma_Data.usr_uart2.DMAbuff,&userUart.userUart2.ReciveBuff,userUart.userUart2.uartRecCount);
// //			memset((uint8_t *)&userUart.userUart2.ReciveBuff,0,sizeof(userUart.userUart2.ReciveBuff));
// //			userUart.userUart2.uartRecCount = 0;
// 			HAL_UART_Receive_DMA(&huart2, (uint8_t *)&userUart.userUart2.ReciveBuff, sizeof(userUart.userUart2.ReciveBuff));
// 			__HAL_UART_CLEAR_IDLEFLAG(&huart2);
// 		}
// 	}
// }

// void UART3_IRQ_DataGet()//在串口1的中断服务函数中添加此函数用于缓存数据
// {
// 	if(USART3 == huart3.Instance)
// 	{
// 		if(__HAL_UART_GET_FLAG(&huart3,UART_FLAG_IDLE))
// 		{
// 			HAL_UART_DMAStop(&huart3);
// 			userUart.userUart3.uartRecCount = MAX_REC_COUNT - __HAL_DMA_GET_COUNTER(&hdma_usart3_rx);//用于统计DMA接收到了多少数据
// 			userUart.userUart3.RecFlag = true;
// //			printf("userUart.userUart3.uartRecCount is %d",userUart.userUart3.uartRecCount);
// //			memcpy(&usr_dma_Data.usr_uart3.DMAbuff,&userUart.userUart3.ReciveBuff,userUart.userUart3.uartRecCount);
// //			memset((uint8_t *)&userUart.userUart3.ReciveBuff,0,sizeof(userUart.userUart3.ReciveBuff));
// //			userUart.userUart3.uartRecCount = 0;
// 			HAL_UART_Receive_DMA(&huart3, (uint8_t *)&userUart.userUart3.ReciveBuff, sizeof(userUart.userUart3.ReciveBuff));
// 			__HAL_UART_CLEAR_IDLEFLAG(&huart3);
// 		}
// 	}
// }



// void USART2_IRQHandler(void)
// {
//   if(__HAL_UART_GET_FLAG(&huart2,UART_IT_IDLE) != RESET)
//   {
//     __HAL_UART_CLEAR_IDLEFLAG(&huart2);
//     HAL_UART_DMAStop(&huart2);
//     HAL_UART_Receive_DMA(Usart_Screen.usart_handle,Usart_Screen.recv_buff,Usart_Screen.recv_buff_size);
//   }
// }
// void USART3_IRQHandler(void)
// {

// }
// void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
// {
//   if(huart->Instance == USART3)
//   {
//     // HAL_UARTEx_ReceiveToIdle_DMA(Usart.usart_handle,Usart.recv_buff,Usart.recv_buff_size);
//     // HAL_UART_Transmit(Usart.usart_handle,Usart.recv_buff,Usart.recv_buff_size,10);
//     // __HAL_DMA_DISABLE_IT(Usart.usart_handle->hdmarx, DMA_IT_HT);
//     HAL_UART_IRQHandler(Usart_2_4G.usart_handle);
//     HAL_UART_Receive_IT(Usart_2_4G.usart_handle,Usart_2_4G.recv_buff,Usart_2_4G.recv_buff_size);
//   }
//   else if(huart->Instance == USART2)
//   {
//     // HAL_UARTEx_ReceiveToIdle_DMA(Usart.usart_handle,Usart.recv_buff,Usart.recv_buff_size);
//     // HAL_UART_Transmit(Usart.usart_handle,Usart.recv_buff,Usart.recv_buff_size,10);
//     // __HAL_DMA_DISABLE_IT(Usart.usart_handle->hdmarx, DMA_IT_HT);
//     HAL_UART_IRQHandler(Usart_Screen.usart_handle);
//     HAL_UART_Receive_IT(Usart_Screen.usart_handle,Usart_Screen.recv_buff,Usart_Screen.recv_buff_size);
//   }
//   else if(huart->Instance == USART1)
//   {
//     // HAL_UARTEx_ReceiveToIdle_DMA(Usart.usart_handle,Usart.recv_buff,Usart.recv_buff_size);
//     // HAL_UART_Transmit(Usart.usart_handle,Usart.recv_buff,Usart.recv_buff_size,10);
//     // __HAL_DMA_DISABLE_IT(Usart.usart_handle->hdmarx, DMA_IT_HT);
//     HAL_UART_IRQHandler(Usart_Text.usart_handle);
//     HAL_UART_Receive_IT(Usart_Text.usart_handle,Usart_Text.recv_buff,Usart_Text.recv_buff_size);
//   }
// }



